// $ANTLR 3.2 Sep 23, 2009 12:02:23 Acd.g 2010-01-18 20:27:02

package net.bioteam.appweb.acd;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class AcdLexer extends Lexer {
    public static final int BRACKETLEFT=6;
    public static final int ATTRVALUE=13;
    public static final int SECTION=9;
    public static final int LINE_COMMENT=16;
    public static final int LETTER=14;
    public static final int ATTRIBUTE=10;
    public static final int DQ=4;
    public static final int ID=12;
    public static final int EOF=-1;
    public static final int BRACKETRIGHT=7;
    public static final int COLON=5;
    public static final int T__19=19;
    public static final int WS=15;
    public static final int T__18=18;
    public static final int VARIABLE=17;
    public static final int PARAMETER=8;
    public static final int PROGRAM=11;

    // delegates
    // delegators

    public AcdLexer() {;} 
    public AcdLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public AcdLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "Acd.g"; }

    // $ANTLR start "DQ"
    public final void mDQ() throws RecognitionException {
        try {
            int _type = DQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:11:4: ( '\"' )
            // Acd.g:11:6: '\"'
            {
            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DQ"

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:12:7: ( ':' )
            // Acd.g:12:9: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "BRACKETLEFT"
    public final void mBRACKETLEFT() throws RecognitionException {
        try {
            int _type = BRACKETLEFT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:13:13: ( '[' )
            // Acd.g:13:15: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BRACKETLEFT"

    // $ANTLR start "BRACKETRIGHT"
    public final void mBRACKETRIGHT() throws RecognitionException {
        try {
            int _type = BRACKETRIGHT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:14:14: ( ']' )
            // Acd.g:14:16: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BRACKETRIGHT"

    // $ANTLR start "T__18"
    public final void mT__18() throws RecognitionException {
        try {
            int _type = T__18;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:15:7: ( 'section' )
            // Acd.g:15:9: 'section'
            {
            match("section"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__18"

    // $ANTLR start "T__19"
    public final void mT__19() throws RecognitionException {
        try {
            int _type = T__19;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:16:7: ( 'endsection' )
            // Acd.g:16:9: 'endsection'
            {
            match("endsection"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__19"

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:61:4: ( LETTER ( LETTER | '-' )* )
            // Acd.g:61:5: LETTER ( LETTER | '-' )*
            {
            mLETTER(); 
            // Acd.g:61:12: ( LETTER | '-' )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0=='-'||(LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // Acd.g:
            	    {
            	    if ( input.LA(1)=='-'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ID"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:62:4: ( ( '\\t' | ' ' | '\\r' | '\\n' )+ )
            // Acd.g:62:6: ( '\\t' | ' ' | '\\r' | '\\n' )+
            {
            // Acd.g:62:6: ( '\\t' | ' ' | '\\r' | '\\n' )+
            int cnt2=0;
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( ((LA2_0>='\t' && LA2_0<='\n')||LA2_0=='\r'||LA2_0==' ') ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // Acd.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);

             skip(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "ATTRVALUE"
    public final void mATTRVALUE() throws RecognitionException {
        try {
            int _type = ATTRVALUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:64:5: ( '\"' ( . )* '\"' )
            // Acd.g:64:7: '\"' ( . )* '\"'
            {
            match('\"'); 
            // Acd.g:64:11: ( . )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0=='\"') ) {
                    alt3=2;
                }
                else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='\uFFFF')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // Acd.g:64:11: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ATTRVALUE"

    // $ANTLR start "LINE_COMMENT"
    public final void mLINE_COMMENT() throws RecognitionException {
        try {
            int _type = LINE_COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:67:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
            // Acd.g:67:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
            {
            match('#'); 
            // Acd.g:67:11: (~ ( '\\n' | '\\r' ) )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // Acd.g:67:11: ~ ( '\\n' | '\\r' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            // Acd.g:67:25: ( '\\r' )?
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='\r') ) {
                alt5=1;
            }
            switch (alt5) {
                case 1 :
                    // Acd.g:67:25: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }

            match('\n'); 
               
                   
                        skip();
                

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LINE_COMMENT"

    // $ANTLR start "VARIABLE"
    public final void mVARIABLE() throws RecognitionException {
        try {
            int _type = VARIABLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Acd.g:74:9: ( 'variable:' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
            // Acd.g:74:11: 'variable:' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
            {
            match("variable:"); 

            // Acd.g:74:23: (~ ( '\\n' | '\\r' ) )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // Acd.g:74:23: ~ ( '\\n' | '\\r' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);

            // Acd.g:74:37: ( '\\r' )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0=='\r') ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // Acd.g:74:37: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }

            match('\n'); 
             skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VARIABLE"

    // $ANTLR start "LETTER"
    public final void mLETTER() throws RecognitionException {
        try {
            // Acd.g:76:8: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )
            // Acd.g:
            {
            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "LETTER"

    public void mTokens() throws RecognitionException {
        // Acd.g:1:8: ( DQ | COLON | BRACKETLEFT | BRACKETRIGHT | T__18 | T__19 | ID | WS | ATTRVALUE | LINE_COMMENT | VARIABLE )
        int alt8=11;
        alt8 = dfa8.predict(input);
        switch (alt8) {
            case 1 :
                // Acd.g:1:10: DQ
                {
                mDQ(); 

                }
                break;
            case 2 :
                // Acd.g:1:13: COLON
                {
                mCOLON(); 

                }
                break;
            case 3 :
                // Acd.g:1:19: BRACKETLEFT
                {
                mBRACKETLEFT(); 

                }
                break;
            case 4 :
                // Acd.g:1:31: BRACKETRIGHT
                {
                mBRACKETRIGHT(); 

                }
                break;
            case 5 :
                // Acd.g:1:44: T__18
                {
                mT__18(); 

                }
                break;
            case 6 :
                // Acd.g:1:50: T__19
                {
                mT__19(); 

                }
                break;
            case 7 :
                // Acd.g:1:56: ID
                {
                mID(); 

                }
                break;
            case 8 :
                // Acd.g:1:59: WS
                {
                mWS(); 

                }
                break;
            case 9 :
                // Acd.g:1:62: ATTRVALUE
                {
                mATTRVALUE(); 

                }
                break;
            case 10 :
                // Acd.g:1:72: LINE_COMMENT
                {
                mLINE_COMMENT(); 

                }
                break;
            case 11 :
                // Acd.g:1:85: VARIABLE
                {
                mVARIABLE(); 

                }
                break;

        }

    }


    protected DFA8 dfa8 = new DFA8(this);
    static final String DFA8_eotS =
        "\1\uffff\1\13\3\uffff\3\12\5\uffff\17\12\1\37\2\12\1\uffff\3\12"+
        "\1\uffff\1\45\1\uffff";
    static final String DFA8_eofS =
        "\46\uffff";
    static final String DFA8_minS =
        "\1\11\1\0\3\uffff\1\145\1\156\1\141\5\uffff\1\143\1\144\1\162\1"+
        "\164\1\163\2\151\1\145\1\141\1\157\1\143\1\142\1\156\1\164\1\154"+
        "\1\55\1\151\1\145\1\uffff\1\157\1\72\1\156\1\uffff\1\55\1\uffff";
    static final String DFA8_maxS =
        "\1\172\1\uffff\3\uffff\1\145\1\156\1\141\5\uffff\1\143\1\144\1"+
        "\162\1\164\1\163\2\151\1\145\1\141\1\157\1\143\1\142\1\156\1\164"+
        "\1\154\1\172\1\151\1\145\1\uffff\1\157\1\72\1\156\1\uffff\1\172"+
        "\1\uffff";
    static final String DFA8_acceptS =
        "\2\uffff\1\2\1\3\1\4\3\uffff\1\10\1\12\1\7\1\1\1\11\22\uffff\1"+
        "\5\3\uffff\1\13\1\uffff\1\6";
    static final String DFA8_specialS =
        "\1\uffff\1\0\44\uffff}>";
    static final String[] DFA8_transitionS = {
            "\2\10\2\uffff\1\10\22\uffff\1\10\1\uffff\1\1\1\11\14\uffff"+
            "\12\12\1\2\6\uffff\32\12\1\3\1\uffff\1\4\1\uffff\1\12\1\uffff"+
            "\4\12\1\6\15\12\1\5\2\12\1\7\4\12",
            "\0\14",
            "",
            "",
            "",
            "\1\15",
            "\1\16",
            "\1\17",
            "",
            "",
            "",
            "",
            "",
            "\1\20",
            "\1\21",
            "\1\22",
            "\1\23",
            "\1\24",
            "\1\25",
            "\1\26",
            "\1\27",
            "\1\30",
            "\1\31",
            "\1\32",
            "\1\33",
            "\1\34",
            "\1\35",
            "\1\36",
            "\1\12\2\uffff\12\12\7\uffff\32\12\4\uffff\1\12\1\uffff\32"+
            "\12",
            "\1\40",
            "\1\41",
            "",
            "\1\42",
            "\1\43",
            "\1\44",
            "",
            "\1\12\2\uffff\12\12\7\uffff\32\12\4\uffff\1\12\1\uffff\32"+
            "\12",
            ""
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( DQ | COLON | BRACKETLEFT | BRACKETRIGHT | T__18 | T__19 | ID | WS | ATTRVALUE | LINE_COMMENT | VARIABLE );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA8_1 = input.LA(1);

                        s = -1;
                        if ( ((LA8_1>='\u0000' && LA8_1<='\uFFFF')) ) {s = 12;}

                        else s = 11;

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 8, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

}